Scroll Progress Bar

Overloading

Function overloading in C++ allows to define multiple functions with the same name but different parameter lists within the same scope (such as within a class or a namespace). The compiler determines which version of the function to call based on the number or type of arguments passed to it. Function overloading is a form of polymorphism and is commonly used to provide multiple ways to perform similar operations.

Here are the key aspects of function overloading in C++:

1. Function Signature:

Function overloads must have the same name but different parameter lists, which includes the number and/or types of parameters. The return type alone doesn't differentiate overloaded functions.

2. Example of Function Overloading:
Program:

// Function to add two integers
int add(int a, int b) {
    return a + b;
}

// Function to add two doubles
double add(double a, double b) {
    return a + b;
}

// Function to concatenate two strings
std::string add(const std::string& str1, const std::string& str2) {
    return str1 + str2;
}

In this example, three overloaded functions named add, each taking different types of parameters.

3. Resolving Overloaded Functions:

When call an overloaded function, the compiler determines which version to call based on the arguments pass. It matches the function call with the function signature that best matches the arguments. If no exact match is found, it attempts to perform type conversions (e.g., from int to double) to find a suitable match.

Program:

int sum1 = add(5, 3);             // Calls the int add(int, int) function
double sum2 = add(2.5, 3.7);      // Calls the double add(double, double) function
std::string result = add("Hello", " World"); // Calls the std::string add(const std::string&, const std::string&) function
4. Default Arguments and Function Overloading:

Function overloading it can also be combined with default arguments to provide even more flexibility.

Program:

// Function to calculate the area of a rectangle
double calculateArea(double length, double width = 1.0) {
    return length * width;
}

In this case, it can call calculateArea(5.0) without specifying the width, and it will use the default value of 1.0. But it can also call calculateArea(5.0, 3.0) to provide a specific width.

5. Operator Overloading:

In C++, it can overload operators for user-defined classes to define custom behaviors when using those operators with objects of that class.

Program:

class Complex {
public:
    double real;
    double imag;

    Complex operator+(const Complex& other) {
        Complex result;
        result.real = real + other.real;
        result.imag = imag + other.imag;
        return result;
    }
};

Here, the + operator is overloaded to add two complex numbers.

Function overloading makes C++ code more expressive and allows to create functions with the same name that work differently depending on the data types or number of arguments provided. This it can lead to more intuitive and readable code in many situations.


question

answer

question2

answer2